home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / preloaders / DownloadProgressBar.as next >
Encoding:
Text File  |  2009-02-12  |  26.4 KB  |  812 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.GradientType;
  5.    import flash.display.Graphics;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.TimerEvent;
  13.    import flash.geom.Matrix;
  14.    import flash.geom.Rectangle;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.text.TextField;
  19.    import flash.text.TextFormat;
  20.    import flash.utils.Timer;
  21.    import flash.utils.getDefinitionByName;
  22.    import flash.utils.getTimer;
  23.    import mx.core.mx_internal;
  24.    import mx.events.FlexEvent;
  25.    import mx.events.RSLEvent;
  26.    import mx.graphics.RectangularDropShadow;
  27.    import mx.graphics.RoundedRectangle;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DownloadProgressBar extends Sprite implements IPreloaderDisplay
  32.    {
  33.       mx_internal static const VERSION:String = "3.0.0.0";
  34.       
  35.       private static var _initializingLabel:String = "Initializing";
  36.       
  37.       protected var MINIMUM_DISPLAY_TIME:uint = 0;
  38.       
  39.       private var _barFrameRect:RoundedRectangle;
  40.       
  41.       private var _stageHeight:Number = 375;
  42.       
  43.       private var _stageWidth:Number = 500;
  44.       
  45.       private var _percentRect:Rectangle;
  46.       
  47.       private var _percentObj:TextField;
  48.       
  49.       private var _downloadingLabel:String = "Loading";
  50.       
  51.       private var _showProgressBar:Boolean = true;
  52.       
  53.       private var _yOffset:Number = 20;
  54.       
  55.       private var _initProgressCount:uint = 0;
  56.       
  57.       private var _barSprite:Sprite;
  58.       
  59.       private var _visible:Boolean = false;
  60.       
  61.       private var _barRect:RoundedRectangle;
  62.       
  63.       private var _showingDisplay:Boolean = false;
  64.       
  65.       private var _backgroundSize:String = "";
  66.       
  67.       private var _initProgressTotal:uint = 12;
  68.       
  69.       private var _startedInit:Boolean = false;
  70.       
  71.       private var _showLabel:Boolean = true;
  72.       
  73.       private var _value:Number = 0;
  74.       
  75.       private var _labelRect:Rectangle;
  76.       
  77.       private var _backgroundImage:Object;
  78.       
  79.       private var _backgroundAlpha:Number = 1;
  80.       
  81.       private var _backgroundColor:uint;
  82.       
  83.       private var _startedLoading:Boolean = false;
  84.       
  85.       private var _showPercentage:Boolean = false;
  86.       
  87.       private var _barFrameSprite:Sprite;
  88.       
  89.       protected var DOWNLOAD_PERCENTAGE:uint = 60;
  90.       
  91.       private var _displayStartCount:uint = 0;
  92.       
  93.       private var _labelObj:TextField;
  94.       
  95.       private var _borderRect:RoundedRectangle;
  96.       
  97.       private var _maximum:Number = 0;
  98.       
  99.       private var _displayTime:int;
  100.       
  101.       private var _label:String = "";
  102.       
  103.       private var _preloader:Sprite;
  104.       
  105.       private var _xOffset:Number = 20;
  106.       
  107.       private var _startTime:int;
  108.       
  109.       public function DownloadProgressBar()
  110.       {
  111.          _labelRect = labelRect;
  112.          _percentRect = percentRect;
  113.          _borderRect = borderRect;
  114.          _barFrameRect = barFrameRect;
  115.          _barRect = barRect;
  116.          super();
  117.       }
  118.       
  119.       public static function get initializingLabel() : String
  120.       {
  121.          return _initializingLabel;
  122.       }
  123.       
  124.       public static function set initializingLabel(param1:String) : void
  125.       {
  126.          _initializingLabel = param1;
  127.       }
  128.       
  129.       protected function getPercentLoaded(param1:Number, param2:Number) : Number
  130.       {
  131.          var _loc3_:Number = NaN;
  132.          if(param1 == 0 || param2 == 0 || isNaN(param2) || isNaN(param1))
  133.          {
  134.             return 0;
  135.          }
  136.          _loc3_ = 100 * param1 / param2;
  137.          if(isNaN(_loc3_) || _loc3_ <= 0)
  138.          {
  139.             return 0;
  140.          }
  141.          if(_loc3_ > 99)
  142.          {
  143.             return 99;
  144.          }
  145.          return Math.round(_loc3_);
  146.       }
  147.       
  148.       protected function get labelFormat() : TextFormat
  149.       {
  150.          var _loc1_:TextFormat = new TextFormat();
  151.          _loc1_.color = 3355443;
  152.          _loc1_.font = "Verdana";
  153.          _loc1_.size = 10;
  154.          return _loc1_;
  155.       }
  156.       
  157.       private function calcScale() : void
  158.       {
  159.          var _loc1_:Number = NaN;
  160.          if(stageWidth < 160 || stageHeight < 120)
  161.          {
  162.             scaleX = 1;
  163.             scaleY = 1;
  164.          }
  165.          else if(stageWidth < 240 || stageHeight < 150)
  166.          {
  167.             createChildren();
  168.             _loc1_ = Math.min(stageWidth / 240,stageHeight / 150);
  169.             scaleX = _loc1_;
  170.             scaleY = _loc1_;
  171.          }
  172.          else
  173.          {
  174.             createChildren();
  175.          }
  176.       }
  177.       
  178.       protected function get percentRect() : Rectangle
  179.       {
  180.          return new Rectangle(108,4,34,16);
  181.       }
  182.       
  183.       protected function set showLabel(param1:Boolean) : void
  184.       {
  185.          _showLabel = param1;
  186.          draw();
  187.       }
  188.       
  189.       private function calcBackgroundSize() : Number
  190.       {
  191.          var _loc2_:int = 0;
  192.          var _loc1_:Number = NaN;
  193.          if(backgroundSize)
  194.          {
  195.             _loc2_ = int(backgroundSize.indexOf("%"));
  196.             if(_loc2_ != -1)
  197.             {
  198.                _loc1_ = Number(backgroundSize.substr(0,_loc2_));
  199.             }
  200.          }
  201.          return _loc1_;
  202.       }
  203.       
  204.       private function show() : void
  205.       {
  206.          _showingDisplay = true;
  207.          calcScale();
  208.          draw();
  209.          _displayTime = getTimer();
  210.       }
  211.       
  212.       private function loadBackgroundImage(param1:Object) : void
  213.       {
  214.          var cls:Class = null;
  215.          var newStyleObj:DisplayObject = null;
  216.          var loader:Loader = null;
  217.          var loaderContext:LoaderContext = null;
  218.          var classOrString:Object = param1;
  219.          if(Boolean(classOrString) && Boolean(classOrString as Class))
  220.          {
  221.             cls = Class(classOrString);
  222.             initBackgroundImage(new cls());
  223.          }
  224.          else if(Boolean(classOrString) && classOrString is String)
  225.          {
  226.             try
  227.             {
  228.                cls = Class(getDefinitionByName(String(classOrString)));
  229.             }
  230.             catch(e:Error)
  231.             {
  232.             }
  233.             if(cls)
  234.             {
  235.                newStyleObj = new cls();
  236.                initBackgroundImage(newStyleObj);
  237.             }
  238.             else
  239.             {
  240.                loader = new Loader();
  241.                loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loader_completeHandler);
  242.                loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,loader_ioErrorHandler);
  243.                loaderContext = new LoaderContext();
  244.                loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  245.                loader.load(new URLRequest(String(classOrString)),loaderContext);
  246.             }
  247.          }
  248.       }
  249.       
  250.       protected function set showPercentage(param1:Boolean) : void
  251.       {
  252.          _showPercentage = param1;
  253.          draw();
  254.       }
  255.       
  256.       protected function get barFrameRect() : RoundedRectangle
  257.       {
  258.          return new RoundedRectangle(14,40,154,4);
  259.       }
  260.       
  261.       private function loader_ioErrorHandler(param1:IOErrorEvent) : void
  262.       {
  263.       }
  264.       
  265.       protected function rslErrorHandler(param1:RSLEvent) : void
  266.       {
  267.          _preloader.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  268.          _preloader.removeEventListener(Event.COMPLETE,completeHandler);
  269.          _preloader.removeEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  270.          _preloader.removeEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  271.          _preloader.removeEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  272.          _preloader.removeEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  273.          _preloader.removeEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  274.          if(!_showingDisplay)
  275.          {
  276.             show();
  277.             _showingDisplay = true;
  278.          }
  279.          label = "RSL Error " + (param1.rslIndex + 1) + " of " + param1.rslTotal;
  280.          var _loc2_:ErrorField = new ErrorField(this.parent);
  281.          _loc2_.show(param1.errorText);
  282.       }
  283.       
  284.       protected function rslCompleteHandler(param1:RSLEvent) : void
  285.       {
  286.          label = "Loaded library " + param1.rslIndex + " of " + param1.rslTotal;
  287.       }
  288.       
  289.       protected function get borderRect() : RoundedRectangle
  290.       {
  291.          return new RoundedRectangle(0,0,182,60,4);
  292.       }
  293.       
  294.       protected function showDisplayForDownloading(param1:int, param2:ProgressEvent) : Boolean
  295.       {
  296.          return param1 > 700 && param2.bytesLoaded < param2.bytesTotal / 2;
  297.       }
  298.       
  299.       protected function createChildren() : void
  300.       {
  301.          var _loc2_:TextField = null;
  302.          var _loc3_:TextField = null;
  303.          var _loc1_:Graphics = graphics;
  304.          if(backgroundColor != 4294967295)
  305.          {
  306.             _loc1_.beginFill(backgroundColor,backgroundAlpha);
  307.             _loc1_.drawRect(0,0,stageWidth,stageHeight);
  308.          }
  309.          if(backgroundImage != null)
  310.          {
  311.             loadBackgroundImage(backgroundImage);
  312.          }
  313.          _barFrameSprite = new Sprite();
  314.          _barSprite = new Sprite();
  315.          addChild(_barFrameSprite);
  316.          addChild(_barSprite);
  317.          _loc1_.beginFill(13421772,0.4);
  318.          _loc1_.drawRoundRect(calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height,_borderRect.cornerRadius * 2,_borderRect.cornerRadius * 2);
  319.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  320.          _loc1_.endFill();
  321.          _loc1_.beginFill(13421772,0.4);
  322.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  323.          _loc1_.endFill();
  324.          var _loc4_:Graphics = _barFrameSprite.graphics;
  325.          var _loc5_:Matrix = new Matrix();
  326.          _loc5_.createGradientBox(_barFrameRect.width,_barFrameRect.height,Math.PI / 2,calcX(_barFrameRect.x),calcY(_barFrameRect.y));
  327.          _loc4_.beginGradientFill(GradientType.LINEAR,[6054502,11909306],[1,1],[0,255],_loc5_);
  328.          _loc4_.drawRoundRect(calcX(_barFrameRect.x),calcY(_barFrameRect.y),_barFrameRect.width,_barFrameRect.height,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  329.          _loc4_.drawRoundRect(calcX(_barFrameRect.x + 1),calcY(_barFrameRect.y + 1),_barFrameRect.width - 2,_barFrameRect.height - 2,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  330.          _loc4_.endFill();
  331.          _labelObj = new TextField();
  332.          _labelObj.x = calcX(_labelRect.x);
  333.          _labelObj.y = calcY(_labelRect.y);
  334.          _labelObj.width = _labelRect.width;
  335.          _labelObj.height = _labelRect.height;
  336.          _labelObj.selectable = false;
  337.          _labelObj.defaultTextFormat = labelFormat;
  338.          addChild(_labelObj);
  339.          _percentObj = new TextField();
  340.          _percentObj.x = calcX(_percentRect.x);
  341.          _percentObj.y = calcY(_percentRect.y);
  342.          _percentObj.width = _percentRect.width;
  343.          _percentObj.height = _percentRect.height;
  344.          _percentObj.selectable = false;
  345.          _percentObj.defaultTextFormat = percentFormat;
  346.          addChild(_percentObj);
  347.          var _loc6_:RectangularDropShadow = new RectangularDropShadow();
  348.          _loc6_.color = 0;
  349.          _loc6_.angle = 90;
  350.          _loc6_.alpha = 0.6;
  351.          _loc6_.distance = 2;
  352.          _loc6_.tlRadius = _loc6_.trRadius = _loc6_.blRadius = _loc6_.brRadius = _borderRect.cornerRadius;
  353.          _loc6_.drawShadow(_loc1_,calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height);
  354.          _loc1_.lineStyle(1,16777215,0.3);
  355.          _loc1_.moveTo(calcX(_borderRect.x) + _borderRect.cornerRadius,calcY(_borderRect.y));
  356.          _loc1_.lineTo(calcX(_borderRect.x) - _borderRect.cornerRadius + _borderRect.width,calcY(_borderRect.y));
  357.       }
  358.       
  359.       private function draw() : void
  360.       {
  361.          var _loc1_:Number = NaN;
  362.          if(_startedLoading)
  363.          {
  364.             if(!_startedInit)
  365.             {
  366.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * DOWNLOAD_PERCENTAGE / 100);
  367.             }
  368.             else
  369.             {
  370.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * (100 - DOWNLOAD_PERCENTAGE) / 100 + DOWNLOAD_PERCENTAGE);
  371.             }
  372.          }
  373.          else
  374.          {
  375.             _loc1_ = getPercentLoaded(_value,_maximum);
  376.          }
  377.          if(_labelObj)
  378.          {
  379.             _labelObj.text = _label;
  380.          }
  381.          if(_percentObj)
  382.          {
  383.             if(!_showPercentage)
  384.             {
  385.                _percentObj.visible = false;
  386.                _percentObj.text = "";
  387.             }
  388.             else
  389.             {
  390.                _percentObj.text = String(_loc1_) + "%";
  391.             }
  392.          }
  393.          if(Boolean(_barSprite) && Boolean(_barFrameSprite))
  394.          {
  395.             if(!_showProgressBar)
  396.             {
  397.                _barSprite.visible = false;
  398.                _barFrameSprite.visible = false;
  399.             }
  400.             else
  401.             {
  402.                drawProgressBar(_loc1_);
  403.             }
  404.          }
  405.       }
  406.       
  407.       private function timerHandler(param1:Event = null) : void
  408.       {
  409.          dispatchEvent(new Event(Event.COMPLETE));
  410.       }
  411.       
  412.       private function hide() : void
  413.       {
  414.       }
  415.       
  416.       public function get backgroundSize() : String
  417.       {
  418.          return _backgroundSize;
  419.       }
  420.       
  421.       protected function center(param1:Number, param2:Number) : void
  422.       {
  423.          _xOffset = Math.floor((param1 - _borderRect.width) / 2);
  424.          _yOffset = Math.floor((param2 - _borderRect.height) / 2);
  425.       }
  426.       
  427.       protected function progressHandler(param1:ProgressEvent) : void
  428.       {
  429.          var _loc2_:uint = param1.bytesLoaded;
  430.          var _loc3_:uint = param1.bytesTotal;
  431.          var _loc4_:int = getTimer() - _startTime;
  432.          if(_showingDisplay || showDisplayForDownloading(_loc4_,param1))
  433.          {
  434.             if(!_startedLoading)
  435.             {
  436.                show();
  437.                label = downloadingLabel;
  438.                _startedLoading = true;
  439.             }
  440.             setProgress(param1.bytesLoaded,param1.bytesTotal);
  441.          }
  442.       }
  443.       
  444.       protected function initProgressHandler(param1:Event) : void
  445.       {
  446.          var _loc3_:Number = NaN;
  447.          var _loc2_:int = getTimer() - _startTime;
  448.          ++_initProgressCount;
  449.          if(!_showingDisplay && showDisplayForInit(_loc2_,_initProgressCount))
  450.          {
  451.             _displayStartCount = _initProgressCount;
  452.             show();
  453.          }
  454.          else if(_showingDisplay)
  455.          {
  456.             if(!_startedInit)
  457.             {
  458.                _startedInit = true;
  459.                label = initializingLabel;
  460.             }
  461.             _loc3_ = 100 * _initProgressCount / (_initProgressTotal - _displayStartCount);
  462.             setProgress(_loc3_,100);
  463.          }
  464.       }
  465.       
  466.       protected function set downloadingLabel(param1:String) : void
  467.       {
  468.          _downloadingLabel = param1;
  469.       }
  470.       
  471.       public function get stageWidth() : Number
  472.       {
  473.          return _stageWidth;
  474.       }
  475.       
  476.       protected function get showPercentage() : Boolean
  477.       {
  478.          return _showPercentage;
  479.       }
  480.       
  481.       override public function get visible() : Boolean
  482.       {
  483.          return _visible;
  484.       }
  485.       
  486.       public function set stageHeight(param1:Number) : void
  487.       {
  488.          _stageHeight = param1;
  489.       }
  490.       
  491.       public function initialize() : void
  492.       {
  493.          _startTime = getTimer();
  494.          center(stageWidth,stageHeight);
  495.       }
  496.       
  497.       protected function rslProgressHandler(param1:RSLEvent) : void
  498.       {
  499.       }
  500.       
  501.       protected function get barRect() : RoundedRectangle
  502.       {
  503.          return new RoundedRectangle(14,39,154,6,0);
  504.       }
  505.       
  506.       protected function get percentFormat() : TextFormat
  507.       {
  508.          var _loc1_:TextFormat = new TextFormat();
  509.          _loc1_.align = "right";
  510.          _loc1_.color = 0;
  511.          _loc1_.font = "Verdana";
  512.          _loc1_.size = 10;
  513.          return _loc1_;
  514.       }
  515.       
  516.       public function set backgroundImage(param1:Object) : void
  517.       {
  518.          _backgroundImage = param1;
  519.       }
  520.       
  521.       private function calcX(param1:Number) : Number
  522.       {
  523.          return param1 + _xOffset;
  524.       }
  525.       
  526.       private function calcY(param1:Number) : Number
  527.       {
  528.          return param1 + _yOffset;
  529.       }
  530.       
  531.       public function set backgroundAlpha(param1:Number) : void
  532.       {
  533.          _backgroundAlpha = param1;
  534.       }
  535.       
  536.       private function initCompleteHandler(param1:Event) : void
  537.       {
  538.          var _loc3_:Timer = null;
  539.          var _loc2_:int = getTimer() - _displayTime;
  540.          if(_showingDisplay && _loc2_ < MINIMUM_DISPLAY_TIME)
  541.          {
  542.             _loc3_ = new Timer(MINIMUM_DISPLAY_TIME - _loc2_,1);
  543.             _loc3_.addEventListener(TimerEvent.TIMER,timerHandler);
  544.             _loc3_.start();
  545.          }
  546.          else
  547.          {
  548.             timerHandler();
  549.          }
  550.       }
  551.       
  552.       public function set backgroundColor(param1:uint) : void
  553.       {
  554.          _backgroundColor = param1;
  555.       }
  556.       
  557.       private function initBackgroundImage(param1:DisplayObject) : void
  558.       {
  559.          var _loc7_:Number = NaN;
  560.          var _loc8_:Number = NaN;
  561.          var _loc9_:Number = NaN;
  562.          addChildAt(param1,0);
  563.          var _loc2_:Number = param1.width;
  564.          var _loc3_:Number = param1.height;
  565.          var _loc4_:Number = calcBackgroundSize();
  566.          if(isNaN(_loc4_))
  567.          {
  568.             _loc7_ = 1;
  569.             _loc8_ = 1;
  570.          }
  571.          else
  572.          {
  573.             _loc9_ = _loc4_ * 0.01;
  574.             _loc7_ = _loc9_ * stageWidth / _loc2_;
  575.             _loc8_ = _loc9_ * stageHeight / _loc3_;
  576.          }
  577.          param1.scaleX = _loc7_;
  578.          param1.scaleY = _loc8_;
  579.          var _loc5_:Number = Math.round(0.5 * (stageWidth - _loc2_ * _loc7_));
  580.          var _loc6_:Number = Math.round(0.5 * (stageHeight - _loc3_ * _loc8_));
  581.          param1.x = _loc5_;
  582.          param1.y = _loc6_;
  583.          if(!isNaN(backgroundAlpha))
  584.          {
  585.             param1.alpha = backgroundAlpha;
  586.          }
  587.       }
  588.       
  589.       public function set backgroundSize(param1:String) : void
  590.       {
  591.          _backgroundSize = param1;
  592.       }
  593.       
  594.       protected function showDisplayForInit(param1:int, param2:int) : Boolean
  595.       {
  596.          return param1 > 300 && param2 == 2;
  597.       }
  598.       
  599.       protected function get downloadingLabel() : String
  600.       {
  601.          return _downloadingLabel;
  602.       }
  603.       
  604.       private function loader_completeHandler(param1:Event) : void
  605.       {
  606.          var _loc2_:DisplayObject = DisplayObject(LoaderInfo(param1.target).loader);
  607.          initBackgroundImage(_loc2_);
  608.       }
  609.       
  610.       protected function setProgress(param1:Number, param2:Number) : void
  611.       {
  612.          if(!isNaN(param1) && !isNaN(param2) && param1 >= 0 && param2 > 0)
  613.          {
  614.             _value = Number(param1);
  615.             _maximum = Number(param2);
  616.             draw();
  617.          }
  618.       }
  619.       
  620.       public function get stageHeight() : Number
  621.       {
  622.          return _stageHeight;
  623.       }
  624.       
  625.       public function get backgroundImage() : Object
  626.       {
  627.          return _backgroundImage;
  628.       }
  629.       
  630.       public function get backgroundAlpha() : Number
  631.       {
  632.          if(!isNaN(_backgroundAlpha))
  633.          {
  634.             return _backgroundAlpha;
  635.          }
  636.          return 1;
  637.       }
  638.       
  639.       private function drawProgressBar(param1:Number) : void
  640.       {
  641.          var _loc11_:Number = NaN;
  642.          var _loc2_:Graphics = _barSprite.graphics;
  643.          _loc2_.clear();
  644.          var _loc3_:Array = [16777215,16777215];
  645.          var _loc4_:Array = [0,255];
  646.          var _loc5_:Matrix = new Matrix();
  647.          var _loc6_:Number = _barRect.width * param1 / 100;
  648.          var _loc7_:Number = _loc6_ / 2;
  649.          var _loc8_:Number = _barRect.height - 4;
  650.          var _loc9_:Number = calcX(_barRect.x);
  651.          var _loc10_:Number = calcY(_barRect.y) + 2;
  652.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  653.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.39,0.85],_loc4_,_loc5_);
  654.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,_loc8_);
  655.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  656.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.85,1],_loc4_,_loc5_);
  657.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,_loc8_);
  658.          _loc7_ = _loc6_ / 3;
  659.          _loc8_ = _barRect.height;
  660.          _loc10_ = calcY(_barRect.y);
  661.          _loc11_ = _loc10_ + _loc8_ - 1;
  662.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  663.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.05,0.15],_loc4_,_loc5_);
  664.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  665.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  666.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  667.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.25],_loc4_,_loc5_);
  668.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  669.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  670.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  671.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.25,0.1],_loc4_,_loc5_);
  672.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  673.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  674.          _loc7_ = _loc6_ / 3;
  675.          _loc8_ = _barRect.height;
  676.          _loc10_ = calcY(_barRect.y) + 1;
  677.          _loc11_ = calcY(_barRect.y) + _loc8_ - 2;
  678.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  679.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.3],_loc4_,_loc5_);
  680.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  681.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  682.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  683.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.3,0.4],_loc4_,_loc5_);
  684.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  685.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  686.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  687.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.4,0.25],_loc4_,_loc5_);
  688.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  689.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  690.       }
  691.       
  692.       public function get backgroundColor() : uint
  693.       {
  694.          return _backgroundColor;
  695.       }
  696.       
  697.       public function set stageWidth(param1:Number) : void
  698.       {
  699.          _stageWidth = param1;
  700.       }
  701.       
  702.       protected function completeHandler(param1:Event) : void
  703.       {
  704.       }
  705.       
  706.       protected function set label(param1:String) : void
  707.       {
  708.          if(!(param1 is Function))
  709.          {
  710.             _label = param1;
  711.          }
  712.          draw();
  713.       }
  714.       
  715.       public function set preloader(param1:Sprite) : void
  716.       {
  717.          _preloader = param1;
  718.          param1.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  719.          param1.addEventListener(Event.COMPLETE,completeHandler);
  720.          param1.addEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  721.          param1.addEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  722.          param1.addEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  723.          param1.addEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  724.          param1.addEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  725.       }
  726.       
  727.       protected function get label() : String
  728.       {
  729.          return _label;
  730.       }
  731.       
  732.       protected function get labelRect() : Rectangle
  733.       {
  734.          return new Rectangle(14,17,100,16);
  735.       }
  736.       
  737.       override public function set visible(param1:Boolean) : void
  738.       {
  739.          if(!_visible && param1)
  740.          {
  741.             show();
  742.          }
  743.          else if(_visible && !param1)
  744.          {
  745.             hide();
  746.          }
  747.          _visible = param1;
  748.       }
  749.       
  750.       protected function get showLabel() : Boolean
  751.       {
  752.          return _showLabel;
  753.       }
  754.    }
  755. }
  756.  
  757. import flash.display.DisplayObjectContainer;
  758. import flash.display.Sprite;
  759. import flash.display.Stage;
  760. import flash.system.Capabilities;
  761. import flash.text.TextField;
  762. import flash.text.TextFieldAutoSize;
  763. import flash.text.TextFormat;
  764.  
  765. class ErrorField extends Sprite
  766. {
  767.    private const TEXT_MARGIN_PX:int = 10;
  768.    
  769.    private var parentContainer:DisplayObjectContainer;
  770.    
  771.    private const MAX_WIDTH_INCHES:int = 6;
  772.    
  773.    private const MIN_WIDTH_INCHES:int = 2;
  774.    
  775.    public function ErrorField(param1:DisplayObjectContainer)
  776.    {
  777.       super();
  778.       this.parentContainer = param1;
  779.    }
  780.    
  781.    public function show(param1:String) : void
  782.    {
  783.       if(param1 == null || param1.length == 0)
  784.       {
  785.          return;
  786.       }
  787.       var _loc2_:Stage = parentContainer.stage;
  788.       var _loc3_:TextField = new TextField();
  789.       _loc3_.autoSize = TextFieldAutoSize.LEFT;
  790.       _loc3_.multiline = true;
  791.       _loc3_.wordWrap = true;
  792.       _loc3_.background = true;
  793.       _loc3_.defaultTextFormat = labelFormat;
  794.       _loc3_.text = param1;
  795.       _loc3_.width = Math.max(MIN_WIDTH_INCHES * Capabilities.screenDPI,_loc2_.stageWidth - TEXT_MARGIN_PX * 2);
  796.       _loc3_.width = Math.min(MAX_WIDTH_INCHES * Capabilities.screenDPI,_loc3_.width);
  797.       _loc3_.y = Math.max(0,_loc2_.stageHeight - TEXT_MARGIN_PX - _loc3_.height);
  798.       _loc3_.x = (_loc2_.stageWidth - _loc3_.width) / 2;
  799.       parentContainer.addChild(this);
  800.       this.addChild(_loc3_);
  801.    }
  802.    
  803.    protected function get labelFormat() : TextFormat
  804.    {
  805.       var _loc1_:TextFormat = new TextFormat();
  806.       _loc1_.color = 0;
  807.       _loc1_.font = "Verdana";
  808.       _loc1_.size = 10;
  809.       return _loc1_;
  810.    }
  811. }
  812.